home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / modelers / geomview / source.lha / Geomview / src / bin / warp / common / warp.c < prev    next >
C/C++ Source or Header  |  1993-10-28  |  19KB  |  880 lines
  1. #include <string.h>
  2. #include <sys/types.h>
  3. #include <sys/time.h>
  4. #include <stdio.h>
  5. #include <math.h>
  6. #include <limits.h>
  7. #include "geom.h"
  8. #include "bbox.h"
  9. #include "hpoint3.h"
  10. #include "streampool.h"
  11. #include "transform.h"
  12. #include "transobj.h"
  13. #include "lisp.h"
  14. #include "pointlist.h"
  15. #include "pickfunc.h"
  16. #include "ooglutil.h"
  17. #include "warp.h"
  18. #include "api.h"
  19.  
  20. #define FUDGE 1.e-6
  21.  
  22. static char msg[] = "warp.c";
  23.  
  24. /*
  25.  * WarpPoint
  26.  * A modification of the morphing algorithm found in
  27.  * "Feature Based Image Metamorphosis"
  28.  * by Thaddeus Beier and Shawn Neely
  29.  * SIGGRAPH '92 Conference Proceedings
  30.  */
  31.  
  32. /* scale is used to put the object roughly within the unit cube */
  33. void WarpPoint(HPoint3 *old, HPoint3 *new, WarpZone *wz, int n_wz,
  34.            int step, int totsteps, float scale) {
  35.   HPoint3 dsum, Di, tmp;
  36.   double weightsum;
  37.   double weight, dist;
  38.   int i;
  39.   
  40.   if (totsteps <= 0) 
  41.     if (step == totsteps) step = totsteps = 1;
  42.     else return;
  43.  
  44.   HPt3From(&dsum, 0.0, 0.0, 0.0, 1.0);
  45.   weightsum = 0;
  46.   
  47.   if (new == old) {
  48.     HPt3Copy(old, &tmp);
  49.     old = &tmp;
  50.   }
  51.  
  52.   for (i = 0; i < n_wz; i++) {
  53.     
  54.     HPt3Transform(wz[i].T, old, new);
  55.     Di.x = (new->x - old->x) * scale;
  56.     Di.y = (new->y - old->y) * scale;
  57.     Di.z = (new->z - old->z) * scale;
  58.     Di.w = 0.0;
  59.     
  60.     wz[i].RestLocation.w = 1.0;
  61.     dist = scale * HPt3Distance(old, &wz[i].RestLocation);
  62.  
  63.     /* This is the critical line */
  64.     weight = wz[i].a * pow(M_E, -dist*dist*wz[i].b*wz[i].b);
  65.  
  66.     Di.x *= weight;
  67.     Di.y *= weight;
  68.     Di.z *= weight;
  69.     HPt3Add(&dsum, &Di, &dsum);
  70.     
  71.     weightsum += weight;
  72.   }
  73.   
  74.   if (weightsum > FUDGE) {
  75.     dsum.x /= weightsum;
  76.     dsum.y /= weightsum;
  77.     dsum.z /= weightsum;
  78.     dsum.w = 0.0;  
  79.  
  80.   } else HPt3From(&dsum, 0.0, 0.0, 0.0, 0.0);
  81.  
  82.   dsum.x = ((dsum.x / totsteps) * step) / scale;
  83.   dsum.y = ((dsum.y / totsteps) * step) / scale;
  84.   dsum.z = ((dsum.z / totsteps) * step) / scale;
  85.  
  86.   HPt3Add(old, &dsum, new);
  87.   
  88. }
  89.  
  90. void WarpPointN(HPoint3 *old, HPoint3 *new, int n, WarpZone *wz, int n_wz,
  91.         int step, int totsteps, float scale)
  92. {
  93.   int i;
  94.   
  95.   for (i = 0; i < n; i++)
  96.     WarpPoint(&old[i], &new[i], wz, n_wz, step, totsteps, scale);
  97.   
  98. }
  99.  
  100.  
  101. /* That's it for the heavy-duty stuff that actually does the warping.
  102.  * The rest is just stuff to control the widgets, deal with the pipes, 
  103.  * etc */
  104.  
  105. static WarpZone *def;
  106. static vvec warpZoneList;
  107. static int nextName = 1;
  108.  
  109. static pickInterest = 0;
  110.  
  111. static Pool *standardIn, *standardOut;
  112.  
  113. /* 
  114.  * Stuff to read things from Geomview 
  115.  */
  116. Geom *readTarget() {
  117.   Geom *g;
  118.  
  119.   printf ("(echo { )");
  120.   printf("(write geometry - %s bare)", uiGetTarget());
  121.   printf("(echo \"}\\n\" )");
  122.   fflush(stdout);
  123.  
  124.   g = GeomFLoad(stdin, NULL);
  125.   if (g == NULL) uiError("Unable to find geometry", uiGetTarget(), "");
  126.   return g;
  127. }
  128.  
  129.  
  130. float getScaleNormalization(Geom *g) {
  131.   Geom *bbox;
  132.   HPoint3 min, max;
  133.   float tmp, scale;
  134.  
  135.   bbox = GeomBound(g, TM_IDENTITY);
  136.   BBoxMinMax((BBox *)bbox, &min, &max);
  137.   GeomDelete(bbox);
  138.   scale = max.x - min.x;
  139.   tmp = max.y - min.y;
  140.   scale = (scale > tmp) ? scale : tmp;
  141.   tmp = max.z - min.z;
  142.   scale = (scale > tmp) ? scale : tmp;
  143.   if (scale < FUDGE) {
  144.     uiError("Object", "has size", "zero");
  145.     return 1.0;
  146.   }
  147.   else return 1.0 / scale;
  148. }
  149.     
  150.  
  151. /* 
  152.  * Widget stuff 
  153.  */
  154.  
  155. /* Only WidgetCreatAt() includes the progn stuff */
  156. void WidgetCreateAt(float x, float y, float z) {
  157.   WidgetName newname;
  158.  
  159.   apiFreeze();
  160.   printf("(progn ");
  161.   WIDGET_NAME(newname, nextName++);
  162.   WidgetCreateAtNamed(x, y, z, newname);
  163.   printf(")");
  164.   fflush(stdout);
  165.   apiThaw();
  166. }
  167.  
  168. void WidgetCreateAtNamed(float x, float y, float z,
  169.              const char *name) {
  170.   WarpZone *newzone;
  171.  
  172.   newzone = VVINDEX(warpZoneList, WarpZone, VVCOUNT(warpZoneList)++);
  173.   def = VVINDEX(warpZoneList, WarpZone, 0);
  174.   HPt3From(&newzone->RestLocation, x, y, z, 1.0);
  175.   newzone->a = def->a;
  176.   newzone->b = def->b;
  177.               
  178.   printf("(progn ");
  179.   printf("(geometry %s { INST unit { ", name);
  180.   printf("INST unit : WarpWidgetGeom transform : WarpScaleT ");
  181.   printf(" } transform : %sLocationT } )", name);
  182.   printf("(normalization %s none)", name);
  183.   WidgetLocation(name, x, y, z);
  184.   printf(")");        /* progn */
  185.  
  186.   fflush(stdout);
  187.   
  188.   uiAddWidget(name, VVCOUNT(warpZoneList) - 1);
  189.   uiSetSelectedWidget(VVCOUNT(warpZoneList) - 1);
  190. }
  191.  
  192. void WidgetDelete(const char *name) {
  193.   printf("(delete %s)", name);
  194.   fflush(stdout);
  195. }
  196.  
  197. void WidgetLocation(const char *name, float x, float y, float z) {
  198.   Transform T;
  199.  
  200.   printf("(progn ");
  201.   TmTranslate(T, x, y, z);
  202.   printf("(read transform { define %sLocationT ", name);
  203.   fputtransform(stdout, 1, &T[0][0], 0);
  204.   printf(" } ) ");
  205.   printf("(xform-set %s { ", name);
  206.   fputtransform(stdout, 1, &TM_IDENTITY[0][0], 0);
  207.   printf(" } ) ");
  208.   printf(")");        /* End of (progn) */
  209.   fflush(stdout);
  210.  
  211. }
  212.  
  213. void WidgetGetTransform(const char *name, Transform T) {
  214.  
  215.   printf("(echo \"{  \")");
  216.   printf("(write transform - %s world)", name);
  217.   printf("(echo \"}\\n\" )");
  218.   fflush(stdout);
  219.  
  220.   if (!TransStreamIn(standardIn, NULL, T)) {
  221.     uiError("Unable to find transform for", name, "");
  222.     TmIdentity(T);
  223.   }
  224.  
  225. }
  226.  
  227. void WidgetSetTransform(const char *name, Transform T) {
  228.   printf("(xform-set %s ", name);
  229.   TransStreamOut(standardOut, NULL, T);
  230.   printf(")");
  231.   fflush(stdout);
  232. }
  233.  
  234. void WidgetDeleteAll() {
  235.   int i;
  236.  
  237.   printf("(progn "); 
  238.   for (i = VVCOUNT(warpZoneList) - 1; i > 0; i--) {
  239.     WidgetDelete(uiGetWidgetName(i));
  240.     uiDeleteWidget(i);
  241.   }
  242.   printf(")"); 
  243.   fflush(stdout);
  244.   
  245.   VVCOUNT(warpZoneList) = 1;
  246.   vvtrim(&warpZoneList);
  247.   def = VVINDEX(warpZoneList, WarpZone, 0);
  248.   uiSetSelectedWidget(0); 
  249. }
  250.  
  251. /* Call-backs for lisp functions */
  252.  
  253. #define PICK_YES    "(interest (pick self))"
  254. #define PICK_NO        "(uninterest (pick self))"
  255.  
  256. DEFPICKFUNC("(pick COORDSYS GEOMID G V E F P VI EI FI)",
  257.         coordsys,
  258.         id,
  259.         point, pn,
  260.         vertex, vn,
  261.         edge, en,
  262.         face, fn, 10,
  263.         ppath, ppn, 50,
  264.         vi,
  265.         ei, ein,
  266.         fi,
  267.         {
  268.           if (pn != 4) return Lt;
  269.           
  270.           if (uiGetCreateOnPick() && uiWidgetIndex(id) == -1) {
  271.         if (point.w > FUDGE)
  272.           WidgetCreateAt(point.x / point.w, point.y / point.w,
  273.                  point.z / point.w);
  274.         else /* I'm not really sure that this is right */
  275.           WidgetCreateAt(point.x, point.y, point.z);
  276.           } 
  277.           return Lt;
  278.         })
  279.  
  280. LDEFINE(ack, LVOID, "(ack)")
  281. {
  282.   LDECLARE(("ack", LBEGIN,
  283.         LEND));
  284.   if (!pickInterest) {
  285.     printf(PICK_YES);
  286.     fflush(stdout);
  287.     pickInterest = 1;
  288.   } 
  289.   uiThaw();
  290.   return Lt;
  291. }
  292.  
  293. /* These routines will be sent from other external modules, or the user
  294.  * via the (emodule-transmit) command. */
  295.  
  296. LDEFINE(create_widget, LVOID, "(create-widget (x y z [w]))\n\
  297.     Creates a widget at named location.")
  298. {
  299.   HPoint3 point;
  300.   int pn = 4;
  301.  
  302.   LDECLARE(("create-widget", LBEGIN,
  303.         LHOLD, LARRAY, LFLOAT, &point, &pn,
  304.         LEND));
  305.   if (pn == 3) point.w = 1.0;
  306.   else if (pn != 4) return Lnil;
  307.   WidgetCreateAt(point.x / point.w, point.y / point.w, 
  308.          point.z / point.w);
  309.   return Lt;
  310. }
  311.  
  312. LDEFINE(create_widget_grid, LVOID, 
  313.     "(create-widget-grid [(xdimn ydimn zdimn)])\n\
  314.     Creates a grid of widgets.  If xdimn, ydimn, and zdimn are not \n\
  315.     specified, they are assumed to be the default or the values which \n\
  316.     have been specified on the user interface panel.  If they are \n\
  317.     present, they will replace the values in the user interface panels.")
  318. {
  319.   int dim[3], dimn = 3;
  320.   LDECLARE(("create-widget-grid", LBEGIN,
  321.         LOPTIONAL,
  322.         LHOLD, LARRAY, LINT, dim, &dimn,
  323.         LEND));
  324.   if (dimn != 3) {
  325.     dim[0] = uiGetGridX();
  326.     dim[1] = uiGetGridY();
  327.     dim[2] = uiGetGridZ();
  328.   } else {
  329.     uiSetGridX(dim[0]);
  330.     uiSetGridY(dim[1]);
  331.     uiSetGridZ(dim[2]);
  332.   }
  333.   apiPosition();
  334.   return Lt;
  335. }
  336.  
  337. LDEFINE(delete_widget, LVOID,
  338.     "(delete-widget [name])\n\
  339.     Deletes widgets.  If name is present, deletes only that widget. \n\
  340.     If name is not specified, deletes all widgets.")
  341. {
  342.   int index;
  343.   char *name = NULL;
  344.   LDECLARE(("delete-widget", LBEGIN,
  345.         LOPTIONAL, 
  346.         LSTRING, &name,
  347.         LEND));
  348.   if (name != NULL) {
  349.     index = uiWidgetIndex(name);
  350.     if (index == -1) return Lnil;
  351.     uiSetSelectedWidget(index);
  352.     apiDelete();
  353.   }
  354.   else apiDeleteAll();
  355.   return Lt;
  356. }
  357.   
  358.  
  359. LDEFINE(preview, LVOID, 
  360.     "(preview [name])\n\
  361.     Same as pressing the preview button.  name is the object to warp.\n\
  362.     If name is omitted the default object or the object specified on \n\
  363.     the user interface panel will be used.  If name is specified, it \n\
  364.     will replace the value on the user interface panel.")
  365. {
  366.   char *name = NULL;
  367.   LDECLARE(("preview", LBEGIN,
  368.        LOPTIONAL,
  369.        LSTRING, &name,
  370.        LEND));
  371.   if (name != NULL) uiSetTarget(name);
  372.   apiPreview();
  373.   return Lt;
  374. }
  375.  
  376. LDEFINE(warp, LVOID, "(warp [name])\n\
  377.     Same as pressing the warp button.name is the object to warp.\n\
  378.         If name is omitted the default object or the object specified on \n\
  379.         the user interface panel will be used.  If name is specified, it \n\
  380.         will replace the value on the user interface panel.")
  381. {
  382.   char *name = NULL;
  383.   LDECLARE(("warp", LBEGIN,
  384.        LOPTIONAL,
  385.        LSTRING, &name,
  386.        LEND));
  387.   if (name != NULL) uiSetTarget(name);
  388.   apiWarp();
  389.   return Lt;
  390. }
  391.   
  392.  
  393.  
  394. LDEFINE(exit, LVOID, "(exit)")
  395. { 
  396.   LDECLARE(("exit", LBEGIN,
  397.         LEND));
  398.   apiExit();
  399.   return Lt;
  400. }
  401.  
  402. /* Things implemented in common code to be called by machine-specific
  403.  * code */
  404.  
  405. void apiFreeze() {
  406.   if (pickInterest) {
  407.     printf(PICK_NO);
  408.     fflush(stdout);
  409.     pickInterest = 0;
  410.   } 
  411.   uiFreeze();
  412. }
  413.  
  414. void apiThaw() {
  415.   printf("(echo \"(ack)\\n\")");
  416.   fflush(stdout); 
  417. }
  418.  
  419. void apiTargetChanged() {
  420.   apiUpdateScale();
  421. }
  422.  
  423. Lake *lake;
  424. LObject *lit, *val;
  425.  
  426. void apiInit() {
  427.  
  428.   uiSetTarget(DEF_OBJECT);
  429.  
  430.   uiSetStrengthBounds(MIN_A, MAX_A);
  431.   uiSetSmoothnessBounds(MIN_B, MAX_B);
  432.  
  433.   uiSetSteps(DEF_INT_STEPS);
  434.   uiSetStart(0);
  435.   uiSetEnd(DEF_INT_STEPS);
  436.  
  437.   uiSetPrefix(DEF_PREFIX);
  438.   uiSetPath(DEF_PATH);
  439.  
  440.   uiSetWidgetGeom(DEF_WIDGET_GEOM);
  441.   uiSetWidgetSize(DEF_WIDGET_SIZE);
  442.  
  443.   uiSetGridX(DEF_GRIDX);
  444.   uiSetGridY(DEF_GRIDY);
  445.   uiSetGridZ(DEF_GRIDZ);
  446.  
  447.   VVINIT(warpZoneList, WarpZone, 8);
  448.   def = VVINDEX(warpZoneList, WarpZone, 0);
  449.   HPt3From(&def->RestLocation, 0.0, 0.0, 0.0, 1.0);
  450.   def->a = DEF_A;
  451.   def->b = DEF_B;
  452.   nextName = 1;
  453.   VVCOUNT(warpZoneList) = 1;
  454.   uiAddWidget("default", 0);
  455.   uiSetSelectedWidget(0);
  456.  
  457.   standardIn = PoolStreamTemp(NULL, stdin, 0, NULL);
  458.   standardOut = PoolStreamTemp(NULL, stdout, 1, NULL);
  459.  
  460.   apiUpdateGeom();
  461.   apiUpdateScale();
  462.  
  463.   LInit();
  464.   lake = LakeDefine(stdin, stdout, NULL);
  465.   printf(PICK_YES);
  466.   fflush(stdout);
  467.   pickInterest = 1;
  468.   LDefun("pick", Lpick, Hpick);
  469.   LDefun("ack", Lack, Hack);
  470.  
  471.   LDefun("create-widget", Lcreate_widget, Hcreate_widget);
  472.   LDefun("create-widget-grid", Lcreate_widget_grid, Hcreate_widget_grid);
  473.   LDefun("delete-widget", Ldelete_widget, Hdelete_widget);
  474.   LDefun("preview", Lpreview, Hpreview);
  475.   LDefun("warp", Lwarp, Hwarp);
  476.   LDefun("exit", Lexit, Hexit);
  477.   
  478.   pointlist_init();
  479.  
  480. }
  481.  
  482. int apiCheckPipes() {
  483.   if (async_fnextc(stdin, 0) != NODATA) {
  484.     apiDoPipes();
  485.     return 1;
  486.   } else {
  487.     static struct timeval tenth = { 0, 100000 };
  488.     select(0, NULL, NULL, NULL, &tenth);
  489.     return 0;
  490.   }
  491. }
  492.  
  493. void apiDoPipes() {
  494.   lit = LSexpr(lake);
  495.   val = LEval(lit);
  496.   LFree(lit);
  497.   LFree(val);
  498. }
  499.  
  500. int apiVerifyUI() {
  501.   int bad = 0;
  502.  
  503.   if (!strlen(uiGetTarget())) {
  504.     uiSetTarget(DEF_OBJECT);
  505.     bad = 1;
  506.   }
  507.   if (uiGetSelectedWidget() < 0 || 
  508.       uiGetSelectedWidget() > VVCOUNT(warpZoneList) - 1) {
  509.     uiSetSelectedWidget(0);
  510.     bad = 1;
  511.   }
  512.   if (uiGetSteps() < 0) {
  513.     uiSetSteps(DEF_INT_STEPS);
  514.     bad = 1;
  515.   }
  516.   if (uiGetStart() < 0) {
  517.     uiSetStart(0);
  518.     bad = 1;
  519.   }
  520.   if (uiGetEnd() != uiGetStart() + uiGetSteps()) { 
  521.     uiSetEnd(uiGetStart() + uiGetSteps());
  522.     bad = 1;
  523.   }
  524.   if (!strlen(uiGetPrefix())) {
  525.     uiSetPrefix(DEF_PREFIX);
  526.     bad = 1;
  527.   }
  528.   if (!strlen(uiGetPath())) {
  529.     uiSetPath(DEF_PATH);
  530.     bad = 1;
  531.   }
  532.   if (!strlen(uiGetWidgetGeom())) {
  533.     uiSetWidgetGeom(DEF_WIDGET_GEOM);
  534.     bad = 1;
  535.   }
  536.   if (uiGetWidgetSize() < 0.0) {
  537.     uiSetWidgetSize(DEF_WIDGET_SIZE);
  538.     bad = 1;
  539.   }
  540.   if (uiGetGridX() < 1) {
  541.     uiSetGridX(DEF_GRIDX);
  542.     bad = 1;
  543.   } 
  544.   if (uiGetGridY() < 1) {
  545.     uiSetGridY(DEF_GRIDY);
  546.     bad = 1;
  547.   }
  548.   if (uiGetGridZ() < 1) {
  549.     uiSetGridZ(DEF_GRIDZ);
  550.     bad = 1;
  551.   }
  552.  
  553.   return bad;
  554. }
  555.  
  556. void apiPreview() {
  557.   int n_wz;
  558.   Geom *g;
  559.   int i;
  560.   HPoint3 *points;
  561.   int n_points;
  562.  
  563.   apiFreeze();
  564.   apiVerifyUI();
  565.   
  566.   n_wz = VVCOUNT(warpZoneList) - 1;
  567.   for (i = 1; i < VVCOUNT(warpZoneList); i++)
  568.     WidgetGetTransform(uiGetWidgetName(i), 
  569.                VVINDEX(warpZoneList, WarpZone, i)->T);
  570.   
  571.   if (i == 1) {
  572.     apiThaw();
  573.     return;
  574.   }
  575.  
  576.   g = readTarget();
  577.   if (g == NULL) {
  578.     apiThaw();
  579.     return;
  580.   }
  581.  
  582.   points = PointList_get(g, TM_IDENTITY, POINTLIST_SELF);
  583.   n_points = PointList_length(g);
  584.   WarpPointN(points, points, n_points, VVINDEX(warpZoneList, WarpZone, 1),
  585.          n_wz, 1, 1, getScaleNormalization(g));
  586.   PointList_set(g, POINTLIST_SELF, points);
  587.  
  588.   printf("(geometry preview { ");
  589.   GeomFSave(g, stdout, NULL);
  590.   printf(" } ) ");
  591.   fflush(stdout);
  592.   
  593.   GeomDelete(g);
  594.   OOGLFree(points);
  595.   
  596.   apiThaw();
  597.   
  598. }
  599.  
  600. void apiWarp() {
  601.   WarpZone *wz;
  602.   int n_wz;
  603.   int i;
  604.   Geom *g, *dest;
  605.   HPoint3 *points, *newpoints;
  606.   int n_points;
  607.   int firststep, step, totsteps;
  608.   char buf[512];
  609.   float scale;
  610.   
  611.   apiFreeze();
  612.   
  613.   apiVerifyUI();
  614.   
  615.   n_wz = VVCOUNT(warpZoneList) - 1;
  616.   for (i = 1; i < VVCOUNT(warpZoneList); i++) {
  617.     wz = VVINDEX(warpZoneList, WarpZone, i);
  618.     WidgetGetTransform(uiGetWidgetName(i), wz->T);
  619.     HPt3Transform(wz->T, &wz->RestLocation, &wz->TransLocation);
  620.   }
  621.   
  622.   if (i == 1) {
  623.     apiThaw();
  624.     return;
  625.   }
  626.   
  627.   g = readTarget();
  628.   if (g == NULL) {
  629.     apiThaw();
  630.     return;
  631.   }
  632.   scale = getScaleNormalization(g);
  633.   
  634.   dest = GeomCopy(g);
  635.   
  636.   if (uiGetIntToGV() || uiGetIntToFiles()) {
  637.     firststep = uiGetStart();
  638.     totsteps = uiGetEnd();
  639.     if (uiGetAutoUpdate()) {
  640.       uiSetStart(uiGetStart() + uiGetSteps() + 1);
  641.       uiSetEnd(uiGetEnd() + uiGetSteps() + 1);
  642.     }
  643.   }
  644.   else {
  645.     totsteps = 1;
  646.     firststep = 0;
  647.   }
  648.   
  649.   points = PointList_get(g, TM_IDENTITY, POINTLIST_SELF);
  650.   n_points = PointList_length(g);
  651.   newpoints = OOGLNewNE(HPoint3, n_points, msg);
  652.   bcopy(points, newpoints, n_points * sizeof(HPoint3));
  653.   
  654.   for (step = 1; step <= totsteps; step++) {
  655.     WarpPointN(points, newpoints, n_points,
  656.            VVINDEX(warpZoneList, WarpZone, 1), n_wz, step, totsteps, 
  657.            scale);
  658.     PointList_set(dest, POINTLIST_SELF, newpoints);
  659.     if (uiGetIntToFiles()) {
  660.       sprintf(buf, "%s%s%04d", uiGetPath(), uiGetPrefix(), 
  661.           firststep + step);
  662.       if (GeomSave(dest, buf) == NULL) 
  663.     uiError("Unable to save file", buf, "");
  664.     }
  665.     if (uiGetIntToGV()) {
  666.       if (uiGetRetain()) printf("(new-geometry ");
  667.       else printf("(geometry ");
  668.       printf(" %s { ", uiGetTarget());
  669.       GeomFSave(dest, stdout, NULL);
  670.       printf(" } ) ");
  671.       fflush(stdout);
  672.     }
  673.   }
  674.   
  675.   printf("(progn ");
  676.   
  677.   printf("(geometry %s { ", uiGetTarget());
  678.   GeomFSave(dest, stdout, NULL);
  679.   printf(" } ) ");
  680.   fflush(stdout);
  681.   
  682.   wz = VVINDEX(warpZoneList, WarpZone, 1);
  683.   for (i = 0; i < n_wz; i++) {
  684.     WarpPoint(&wz[i].RestLocation, &wz[i].TransLocation,
  685.           wz, n_wz, 1, 1, scale);
  686.     WidgetLocation(uiGetWidgetName(i+1),
  687.            wz[i].TransLocation.x, wz[i].TransLocation.y,
  688.            wz[i].TransLocation.z);
  689.     WidgetSetTransform(uiGetWidgetName(i+1), TM_IDENTITY);
  690.   }
  691.   for (i = 0; i < n_wz; i++)
  692.     HPt3Copy(&wz[i].TransLocation, &wz[i].RestLocation);
  693.   
  694.   printf(")");        /* End of (progn) */
  695.  
  696.   fflush(stdout);
  697.   
  698.   GeomDelete(g);
  699.   GeomDelete(dest);
  700.   OOGLFree(points);
  701.   OOGLFree(newpoints);
  702.   
  703.   apiThaw();
  704.   
  705. }
  706.  
  707. void apiEdit() {
  708.   int i;
  709.   WarpZone *wz;
  710.  
  711.   i = uiGetSelectedWidget();
  712.   wz = VVINDEX(warpZoneList, WarpZone, i);
  713.   uiSetStrength(wz->a);
  714.   uiSetSmoothness(wz->b);
  715.   uiSetPoint((Point3 *)(&(wz->RestLocation)));
  716.   uiEdit(uiGetWidgetName(i));
  717. }
  718.  
  719. void apiEditSet() {
  720.   int i;
  721.   WarpZone *wz;
  722.  
  723.   i = uiGetSelectedWidget();
  724.   wz = VVINDEX(warpZoneList, WarpZone, i);
  725.   wz->a = uiGetStrength();
  726.   wz->b = uiGetSmoothness();
  727.   uiGetPoint((Point3 *)(&(wz->RestLocation)));
  728.   WidgetLocation(uiGetWidgetName(i), wz->RestLocation.x, wz->RestLocation.y,
  729.          wz->RestLocation.z);
  730. }
  731.  
  732. void apiEditSetAll() {
  733.   int i;
  734.   float a, b;
  735.   a = uiGetStrength();
  736.   b = uiGetSmoothness();
  737.   for (i = 0; i < VVCOUNT(warpZoneList); i++) {
  738.     VVINDEX(warpZoneList, WarpZone, i)->a = a;
  739.     VVINDEX(warpZoneList, WarpZone, i)->b = b;
  740.   }
  741. }
  742.  
  743. void apiEditLocation() {
  744.   int i;
  745.   WarpZone *wz;
  746.  
  747.   i = uiGetSelectedWidget();
  748.   wz = VVINDEX(warpZoneList, WarpZone, i);
  749.   WidgetGetTransform(uiGetWidgetName(i), wz->T);
  750.   HPt3Transform(wz->T, &wz->RestLocation, &wz->TransLocation);
  751.   uiSetPoint((Point3 *)(&(wz->TransLocation)));
  752. }
  753.  
  754. void apiDelete() {
  755.   int i, j;
  756.  
  757.   i = uiGetSelectedWidget();
  758.   if (i < 1) return;
  759.   WidgetDelete(uiGetWidgetName(i));
  760.  
  761.   for (j = i+1; j < VVCOUNT(warpZoneList); j++)
  762.     bcopy(VVINDEX(warpZoneList, WarpZone, j),
  763.       VVINDEX(warpZoneList, WarpZone, j-1), sizeof(WarpZone));
  764.   VVCOUNT(warpZoneList) = VVCOUNT(warpZoneList) - 1;
  765.   uiDeleteWidget(i);
  766.  
  767.   if (i < VVCOUNT(warpZoneList)) uiSetSelectedWidget(i);
  768.   else uiSetSelectedWidget(i-1);
  769.  
  770.   vvtrim(&warpZoneList);
  771.   def = VVINDEX(warpZoneList, WarpZone, 0);
  772. }
  773.  
  774. void apiDeleteAll() {
  775.   apiFreeze(); 
  776.   WidgetDeleteAll();
  777.   apiThaw();
  778. }
  779.  
  780. void apiPosition() {
  781.   int x, y, z, i, j, k;
  782.   Geom *g;
  783.   Geom *bbox;
  784.   HPoint3 min, max;
  785.   float stepx, stepy, stepz;
  786.   WidgetName name;
  787.   
  788.   apiVerifyUI();
  789.   WidgetDeleteAll();
  790.  
  791.   g = readTarget();
  792.   if (g == NULL) return;
  793.   bbox = GeomBound(g, TM_IDENTITY);  
  794.   BBoxMinMax((BBox *)bbox, &min, &max);
  795.  
  796.   x = uiGetGridX();
  797.   y = uiGetGridY();
  798.   z = uiGetGridZ();
  799.   
  800.   if (max.x - min.x < FUDGE) {
  801.     uiSetGridX(1);
  802.     x = 1;
  803.   }
  804.   if (max.y - min.y < FUDGE) {
  805.     uiSetGridY(1);
  806.     y = 1;
  807.   }
  808.   if (max.z - min.z < FUDGE) {
  809.     uiSetGridZ(1);
  810.     z = 1;
  811.   }
  812.   stepx = (max.x - min.x) / (x > 1 ? x-1 : 1);
  813.   stepy = (max.y - min.y) / (y > 1 ? y-1 : 1);
  814.   stepz = (max.z - min.z) / (z > 1 ? z-1 : 1);
  815.  
  816.   printf("(progn ");
  817.   
  818.   for (i = 0; i < x; i++)
  819.     for (j = 0; j < y; j++)
  820.       for (k = 0; k < z; k++) {
  821.     WIDGET_GRIDNAME(name, i, j, k);
  822.     WidgetCreateAtNamed(min.x + stepx * i, min.y + stepy * j,
  823.                 min.z + stepz * k, name);
  824.     
  825.       }
  826.   
  827.   /* Close off progn() statement */
  828.   printf(")");
  829.   fflush(stdout);
  830.   
  831.   GeomDelete(bbox);
  832.   GeomDelete(g);
  833.  
  834. }
  835.  
  836. void apiUpdateGeom() {
  837.   printf("(read geometry { define WarpWidgetGeom < %s })",
  838.      uiGetWidgetGeom());
  839.   fflush(stdout);
  840. }
  841.  
  842. void apiUpdateScale() {
  843.   Transform T;
  844.   float scale;
  845.   Geom *g, *bbox;
  846.   HPoint3 min, max;
  847.   float tmp;
  848.  
  849.   if (uiGetRelativeSize()) {
  850.     g = readTarget();
  851.     if (g == NULL) scale = 1.0;
  852.     else {
  853.       bbox = GeomBound(g, TM_IDENTITY);
  854.       BBoxMinMax((BBox *)bbox, &min, &max);
  855.  
  856.       HPt3Normalize(&min, &min);
  857.       HPt3Normalize(&max, &max);
  858.       scale = max.x - min.x;
  859.       tmp = max.y - min.y;
  860.       if (tmp > scale) scale = tmp;
  861.       tmp = max.z - min.z;
  862.       if (tmp > scale) scale = tmp;
  863.     }
  864.     scale *= uiGetWidgetSize();
  865.   } else scale = uiGetWidgetSize();
  866.  
  867.   TmScale(T, scale, scale, scale);
  868.  
  869.   printf("(read transform { define WarpScaleT ");
  870.   TransStreamOut(standardOut, NULL, T); 
  871.   printf("})");
  872.   fflush(stdout);
  873. }
  874.  
  875. void apiExit() {
  876.   apiDeleteAll();
  877.   exit(0);
  878. }
  879.  
  880.